import { promises as fs } from 'fs'
import path from 'path'
import domainsConfig from '~/public/config/domains.json'

// 定义数据类型
interface DataItem {
  [key: string]: any
}

// 定义二级分类数据（JSON文件数据）
interface SubCategoryData {
  [subCategory: string]: DataItem[]
}

// 定义一级分类数据（文件夹数据）
interface MainCategoryData {
  mainCategories: string[] // 一级分类列表（文件夹名）
  subCategories: { [mainCategory: string]: string[] } // 二级分类列表（JSON文件名）
  categoryData: { [mainCategory: string]: SubCategoryData } // 分类下的app数据
  allData: DataItem[] // 该数据源的所有app合并数据
}

// 定义数据源映射
interface DataSourceMap {
  [dataSource: string]: MainCategoryData
}

// 定义域名数据映射
interface DomainDataMap {
  [domain: string]: {
    dataSource: string
    data: MainCategoryData
  }
}

// 全局变量：存储所有数据源的数据
const dataSourceMap: DataSourceMap = {}

// 全局变量：存储按域名分类的数据
const domainDataMap: DomainDataMap = {}

// 获取当前域名（运行时）
const getCurrentDomain = (event?: any): string => {
  // 在预渲染时返回默认域名
  if (!event || !event.node?.req?.headers?.host) {
    return 'default'
  }
  
  const host = event.node.req.headers.host
  return host.split(':')[0] // 移除端口号
}

// 读取指定数据源下的所有一级分类文件夹
const readDataSourceData = async (dataSourcePath: string, dataSourceName: string): Promise<MainCategoryData> => {
  try {
    const mainCategories = await fs.readdir(dataSourcePath, { withFileTypes: true })
    
    // 只处理文件夹
    const mainCategoryDirs = mainCategories
      .filter(dirent => dirent.isDirectory())
      .map(dirent => dirent.name)
    
    
    const result: MainCategoryData = {
      mainCategories: mainCategoryDirs,
      subCategories: {},
      categoryData: {},
      allData: []
    }
    
    // 读取每个一级分类的数据
    for (const mainCategory of mainCategoryDirs) {
      const mainCategoryPath = path.join(dataSourcePath, mainCategory)
      const subCategories = await fs.readdir(mainCategoryPath, { withFileTypes: true })
      
      // 只处理JSON文件
      const jsonFiles = subCategories
        .filter(dirent => dirent.isFile() && dirent.name.endsWith('.json'))
        .map(dirent => dirent.name.replace('.json', ''))
      
      // 对二级分类进行排序，将"All"排在最前面
      const sortedJsonFiles = [...jsonFiles].sort((a, b) => {
        if (a === 'All') return -1
        if (b === 'All') return 1
        return a.localeCompare(b)
      })
      
      result.subCategories[mainCategory] = sortedJsonFiles
      result.categoryData[mainCategory] = {}
      
      // 读取每个二级分类（JSON文件）的数据
      for (const subCategory of sortedJsonFiles) {
        const jsonFilePath = path.join(mainCategoryPath, `${subCategory}.json`)
        const fileData = await fs.readFile(jsonFilePath, 'utf-8')
        const parsedData = JSON.parse(fileData)
        
        let subCategoryData: DataItem[] = []
        if (Array.isArray(parsedData)) {
          subCategoryData = parsedData
        } else {
          subCategoryData = [parsedData]
        }
        
        result.categoryData[mainCategory][subCategory] = subCategoryData
        result.allData.push(...subCategoryData)
        
      }
    }
    
    // 对一级分类进行排序，将"Trending"排在最前面
    result.mainCategories.sort((a, b) => {
      if (a === 'Trending') return -1
      if (b === 'Trending') return 1
      return a.localeCompare(b)
    })
    
    return result
    
  } catch (error) {
    console.error(`读取数据源 ${dataSourceName} 失败:`, error)
    return {
      mainCategories: [],
      subCategories: {},
      categoryData: {},
      allData: []
    }
  }
}

// 读取public/data下所有数据源
const readAllDataSources = async () => {
  try {
    const dataDir = path.join(process.cwd(), 'public', 'data')
    const dataSources = await fs.readdir(dataDir, { withFileTypes: true })
    
    // 只处理文件夹
    const dataSourceDirs = dataSources
      .filter(dirent => dirent.isDirectory())
      .map(dirent => dirent.name)
    
    // 读取每个数据源的数据
    for (const dataSource of dataSourceDirs) {
      const dataSourcePath = path.join(dataDir, dataSource)
      const dataSourceData = await readDataSourceData(dataSourcePath, dataSource)
      
      // 保存到全局变量
      dataSourceMap[dataSource] = dataSourceData
      
    }
    
    // 根据域名配置组织数据
    await organizeDataByDomain()
    
  } catch (error) {
    console.error('读取数据源失败:', error)
  }
}

// 根据域名配置组织数据
const organizeDataByDomain = async () => {
  try {
    const config = domainsConfig as any
    
    // 遍历所有域名配置
    for (const [domain, domainConfig] of Object.entries(config.domains || {})) {
      const dataSource = (domainConfig as any)?.theme?.dataLayer || 'ai'
      
      // 如果该域名配置了dataSource，则使用对应数据源的数据
      if (dataSource && dataSourceMap[dataSource]) {
        domainDataMap[domain] = {
          dataSource,
          data: dataSourceMap[dataSource]
        }
        // console.log(`域名 ${domain} 配置了数据源 ${dataSource}`)
      }
    }
    
    // 处理默认配置
    if (config.default?.theme?.dataLayer) {
      const defaultDataSource = config.default.theme.dataLayer
      if (dataSourceMap[defaultDataSource]) {
        domainDataMap['default'] = {
          dataSource: defaultDataSource,
          data: dataSourceMap[defaultDataSource]
        }
        // console.log(`默认配置使用数据源 ${defaultDataSource}`)
      }
    }
    
  } catch (error) {
    console.error('组织域名数据失败:', error)
  }
}

// 根据域名获取对应的数据
const getDataByDomain = (domain: string): { dataSource: string; data: MainCategoryData } | null => {
  // 优先匹配当前域名，如果没有，再次匹配主域名，如果都没有，返回default
  if (domainDataMap[domain]) {
    return domainDataMap[domain]
  }
  // mainDomain
  const domainParts = domain.split('.')
  const mainDomain = domainParts.slice(domainParts.length - 2).join('.')
  if (domainDataMap[mainDomain]) {
    return domainDataMap[mainDomain]
  }
  return domainDataMap['default'] || null
}

// 运行时根据请求事件获取当前域名的数据
const getCurrentRequestData = (event?: any): { dataSource: string; data: MainCategoryData } | null => {
  try {
    const domain = getCurrentDomain(event)
    const result = getDataByDomain(domain)
    
    // 如果找不到数据，记录警告但不抛出错误
    if (!result) {
      console.warn(`域名 ${domain} 未找到对应的数据源`)
    }
    
    return result
  } catch (error) {
    console.error('获取当前请求数据失败:', error)
    // 返回默认数据源，避免服务端崩溃
    return getDataByDomain('default')
  }
}

// 获取指定数据源的数据
const getDataSourceData = (dataSource: string): MainCategoryData | null => {
  return dataSourceMap[dataSource] || null
}

// 获取所有数据源的数据
const getAllDataSources = (): DataSourceMap => {
  return dataSourceMap
}

// 获取指定数据源下指定一级分类的数据
const getMainCategoryData = (dataSource: string, mainCategory: string): SubCategoryData | null => {
  const dataSourceData = dataSourceMap[dataSource]
  if (!dataSourceData) return null
  
  return dataSourceData.categoryData[mainCategory] || null
}

// 获取指定数据源下指定一级分类和二级分类的数据
const getSubCategoryData = (dataSource: string, mainCategory: string, subCategory: string): DataItem[] => {
  const mainCategoryData = getMainCategoryData(dataSource, mainCategory)
  if (!mainCategoryData) return []
  
  return mainCategoryData[subCategory] || []
}

// 使用 defineNitroPlugin 让插件在服务器启动时自动执行
export default defineNitroPlugin(async (nitroApp) => {
  console.log('getData 插件开始初始化...')
  await readAllDataSources()
  // console.log(`已加载 ${Object.keys(dataSourceMap).length} 个数据源`)
  // console.log('域名数据映射:', Object.keys(domainDataMap))
  
  // 输出每个数据源的统计信息
  // for (const [dataSource, data] of Object.entries(dataSourceMap)) {
  //   console.log(`数据源 ${dataSource}: ${data.mainCategories.length} 个一级分类，总计 ${data.allData.length} 条数据`)
  // }
})

// 导出获取数据的函数，供其他地方使用
export const getData = () => {
  return {
    dataSourceMap,
    domainDataMap,
    getDataByDomain,
    getCurrentRequestData,
    getDataSourceData,
    getAllDataSources,
    getMainCategoryData,
    getSubCategoryData
  }
}

// 导出类型定义
export type { 
  DataItem, 
  SubCategoryData, 
  MainCategoryData, 
  DataSourceMap, 
  DomainDataMap 
}